//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS BedrockAgentCoreControl service.
///
///   is in preview release and is subject to change.  Welcome to the Amazon Bedrock AgentCore Control plane API reference. Control plane actions configure, create, modify, and monitor Amazon Web Services resources.
public struct BedrockAgentCoreControl: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the BedrockAgentCoreControl client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "BedrockAgentCoreControl",
            serviceIdentifier: "bedrock-agentcore-control",
            signingName: "bedrock-agentcore",
            serviceProtocol: .restjson,
            apiVersion: "2023-06-05",
            endpoint: endpoint,
            errorType: BedrockAgentCoreControlErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Creates an Amazon Bedrock AgentCore Runtime.
    @Sendable
    @inlinable
    public func createAgentRuntime(_ input: CreateAgentRuntimeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAgentRuntimeResponse {
        try await self.client.execute(
            operation: "CreateAgentRuntime", 
            path: "/runtimes/", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Bedrock AgentCore Runtime.
    ///
    /// Parameters:
    ///   - agentRuntimeArtifact: The artifact of the AgentCore Runtime.
    ///   - agentRuntimeName: The name of the AgentCore Runtime.
    ///   - authorizerConfiguration: The authorizer configuration for the AgentCore Runtime.
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: The description of the AgentCore Runtime.
    ///   - environmentVariables: Environment variables to set in the AgentCore Runtime environment.
    ///   - lifecycleConfiguration: The life cycle configuration for the AgentCore Runtime.
    ///   - networkConfiguration: The network configuration for the AgentCore Runtime.
    ///   - protocolConfiguration: 
    ///   - requestHeaderConfiguration: Configuration for HTTP request headers that will be passed through to the runtime.
    ///   - roleArn: The IAM role ARN that provides permissions for the AgentCore Runtime.
    ///   - tags: A map of tag keys and values to assign to the agent runtime. Tags enable you to categorize your resources in different ways, for example, by purpose, owner, or environment.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAgentRuntime(
        agentRuntimeArtifact: AgentRuntimeArtifact,
        agentRuntimeName: String,
        authorizerConfiguration: AuthorizerConfiguration? = nil,
        clientToken: String? = CreateAgentRuntimeRequest.idempotencyToken(),
        description: String? = nil,
        environmentVariables: [String: String]? = nil,
        lifecycleConfiguration: LifecycleConfiguration? = nil,
        networkConfiguration: NetworkConfiguration,
        protocolConfiguration: ProtocolConfiguration? = nil,
        requestHeaderConfiguration: RequestHeaderConfiguration? = nil,
        roleArn: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAgentRuntimeResponse {
        let input = CreateAgentRuntimeRequest(
            agentRuntimeArtifact: agentRuntimeArtifact, 
            agentRuntimeName: agentRuntimeName, 
            authorizerConfiguration: authorizerConfiguration, 
            clientToken: clientToken, 
            description: description, 
            environmentVariables: environmentVariables, 
            lifecycleConfiguration: lifecycleConfiguration, 
            networkConfiguration: networkConfiguration, 
            protocolConfiguration: protocolConfiguration, 
            requestHeaderConfiguration: requestHeaderConfiguration, 
            roleArn: roleArn, 
            tags: tags
        )
        return try await self.createAgentRuntime(input, logger: logger)
    }

    /// Creates an AgentCore Runtime endpoint.
    @Sendable
    @inlinable
    public func createAgentRuntimeEndpoint(_ input: CreateAgentRuntimeEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAgentRuntimeEndpointResponse {
        try await self.client.execute(
            operation: "CreateAgentRuntimeEndpoint", 
            path: "/runtimes/{agentRuntimeId}/runtime-endpoints/", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an AgentCore Runtime endpoint.
    ///
    /// Parameters:
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime to create an endpoint for.
    ///   - agentRuntimeVersion: The version of the AgentCore Runtime to use for the endpoint.
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: The description of the AgentCore Runtime endpoint.
    ///   - name: The name of the AgentCore Runtime endpoint.
    ///   - tags: A map of tag keys and values to assign to the agent runtime endpoint. Tags enable you to categorize your resources in different ways, for example, by purpose, owner, or environment.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAgentRuntimeEndpoint(
        agentRuntimeId: String,
        agentRuntimeVersion: String? = nil,
        clientToken: String? = CreateAgentRuntimeEndpointRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAgentRuntimeEndpointResponse {
        let input = CreateAgentRuntimeEndpointRequest(
            agentRuntimeId: agentRuntimeId, 
            agentRuntimeVersion: agentRuntimeVersion, 
            clientToken: clientToken, 
            description: description, 
            name: name, 
            tags: tags
        )
        return try await self.createAgentRuntimeEndpoint(input, logger: logger)
    }

    /// Creates a new API key credential provider.
    @Sendable
    @inlinable
    public func createApiKeyCredentialProvider(_ input: CreateApiKeyCredentialProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateApiKeyCredentialProviderResponse {
        try await self.client.execute(
            operation: "CreateApiKeyCredentialProvider", 
            path: "/identities/CreateApiKeyCredentialProvider", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new API key credential provider.
    ///
    /// Parameters:
    ///   - apiKey: The API key to use for authentication. This value is encrypted and stored securely.
    ///   - name: The name of the API key credential provider. The name must be unique within your account.
    ///   - tags: A map of tag keys and values to assign to the API key credential provider. Tags enable you to categorize your resources in different ways, for example, by purpose, owner, or environment.
    ///   - logger: Logger use during operation
    @inlinable
    public func createApiKeyCredentialProvider(
        apiKey: String,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateApiKeyCredentialProviderResponse {
        let input = CreateApiKeyCredentialProviderRequest(
            apiKey: apiKey, 
            name: name, 
            tags: tags
        )
        return try await self.createApiKeyCredentialProvider(input, logger: logger)
    }

    /// Creates a custom browser.
    @Sendable
    @inlinable
    public func createBrowser(_ input: CreateBrowserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateBrowserResponse {
        try await self.client.execute(
            operation: "CreateBrowser", 
            path: "/browsers", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a custom browser.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier to ensure that the operation completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request but does not return an error.
    ///   - description: The description of the browser.
    ///   - executionRoleArn: The Amazon Resource Name (ARN) of the IAM role that provides permissions for the browser to access Amazon Web Services services.
    ///   - name: The name of the browser. The name must be unique within your account.
    ///   - networkConfiguration: The network configuration for the browser. This configuration specifies the network mode for the browser.
    ///   - recording: The recording configuration for the browser. When enabled, browser sessions are recorded and stored in the specified Amazon S3 location.
    ///   - tags: A map of tag keys and values to assign to the browser. Tags enable you to categorize your resources in different ways, for example, by purpose, owner, or environment.
    ///   - logger: Logger use during operation
    @inlinable
    public func createBrowser(
        clientToken: String? = CreateBrowserRequest.idempotencyToken(),
        description: String? = nil,
        executionRoleArn: String? = nil,
        name: String,
        networkConfiguration: BrowserNetworkConfiguration,
        recording: RecordingConfig? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateBrowserResponse {
        let input = CreateBrowserRequest(
            clientToken: clientToken, 
            description: description, 
            executionRoleArn: executionRoleArn, 
            name: name, 
            networkConfiguration: networkConfiguration, 
            recording: recording, 
            tags: tags
        )
        return try await self.createBrowser(input, logger: logger)
    }

    /// Creates a custom code interpreter.
    @Sendable
    @inlinable
    public func createCodeInterpreter(_ input: CreateCodeInterpreterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCodeInterpreterResponse {
        try await self.client.execute(
            operation: "CreateCodeInterpreter", 
            path: "/code-interpreters", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a custom code interpreter.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier to ensure that the operation completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request but does not return an error.
    ///   - description: The description of the code interpreter.
    ///   - executionRoleArn: The Amazon Resource Name (ARN) of the IAM role that provides permissions for the code interpreter to access Amazon Web Services services.
    ///   - name: The name of the code interpreter. The name must be unique within your account.
    ///   - networkConfiguration: The network configuration for the code interpreter. This configuration specifies the network mode for the code interpreter.
    ///   - tags: A map of tag keys and values to assign to the code interpreter. Tags enable you to categorize your resources in different ways, for example, by purpose, owner, or environment.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCodeInterpreter(
        clientToken: String? = CreateCodeInterpreterRequest.idempotencyToken(),
        description: String? = nil,
        executionRoleArn: String? = nil,
        name: String,
        networkConfiguration: CodeInterpreterNetworkConfiguration,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCodeInterpreterResponse {
        let input = CreateCodeInterpreterRequest(
            clientToken: clientToken, 
            description: description, 
            executionRoleArn: executionRoleArn, 
            name: name, 
            networkConfiguration: networkConfiguration, 
            tags: tags
        )
        return try await self.createCodeInterpreter(input, logger: logger)
    }

    /// Creates a gateway for Amazon Bedrock Agent. A gateway serves as an integration point between your agent and external services. If you specify CUSTOM_JWT as the authorizerType, you must provide an authorizerConfiguration.
    @Sendable
    @inlinable
    public func createGateway(_ input: CreateGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateGatewayResponse {
        try await self.client.execute(
            operation: "CreateGateway", 
            path: "/gateways/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a gateway for Amazon Bedrock Agent. A gateway serves as an integration point between your agent and external services. If you specify CUSTOM_JWT as the authorizerType, you must provide an authorizerConfiguration.
    ///
    /// Parameters:
    ///   - authorizerConfiguration: The authorizer configuration for the gateway. Required if authorizerType is CUSTOM_JWT.
    ///   - authorizerType: The type of authorizer to use for the gateway.    CUSTOM_JWT - Authorize with a bearer token.    AWS_IAM - Authorize with your Amazon Web Services IAM credentials.
    ///   - clientToken: A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If you don't specify this field, a value is randomly generated for you. If this token matches a previous request, the service ignores the request, but doesn't return an error. For more information, see Ensuring idempotency.
    ///   - description: The description of the gateway.
    ///   - exceptionLevel: The level of detail in error messages returned when invoking the gateway.   If the value is DEBUG, granular exception messages are returned to help a user debug the gateway.   If the value is omitted, a generic error message is returned to the end user.
    ///   - kmsKeyArn: The Amazon Resource Name (ARN) of the KMS key used to encrypt data associated with the gateway.
    ///   - name: The name of the gateway. The name must be unique within your account.
    ///   - protocolConfiguration: The configuration settings for the protocol specified in the protocolType parameter.
    ///   - protocolType: The protocol type for the gateway.
    ///   - roleArn: The Amazon Resource Name (ARN) of the IAM role that provides permissions for the gateway to access Amazon Web Services services.
    ///   - tags: A map of key-value pairs to associate with the gateway as metadata tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func createGateway(
        authorizerConfiguration: AuthorizerConfiguration? = nil,
        authorizerType: AuthorizerType,
        clientToken: String? = CreateGatewayRequest.idempotencyToken(),
        description: String? = nil,
        exceptionLevel: ExceptionLevel? = nil,
        kmsKeyArn: String? = nil,
        name: String,
        protocolConfiguration: GatewayProtocolConfiguration? = nil,
        protocolType: GatewayProtocolType,
        roleArn: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateGatewayResponse {
        let input = CreateGatewayRequest(
            authorizerConfiguration: authorizerConfiguration, 
            authorizerType: authorizerType, 
            clientToken: clientToken, 
            description: description, 
            exceptionLevel: exceptionLevel, 
            kmsKeyArn: kmsKeyArn, 
            name: name, 
            protocolConfiguration: protocolConfiguration, 
            protocolType: protocolType, 
            roleArn: roleArn, 
            tags: tags
        )
        return try await self.createGateway(input, logger: logger)
    }

    /// Creates a target for a gateway. A target defines an endpoint that the gateway can connect to.
    @Sendable
    @inlinable
    public func createGatewayTarget(_ input: CreateGatewayTargetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateGatewayTargetResponse {
        try await self.client.execute(
            operation: "CreateGatewayTarget", 
            path: "/gateways/{gatewayIdentifier}/targets/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a target for a gateway. A target defines an endpoint that the gateway can connect to.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If you don't specify this field, a value is randomly generated for you. If this token matches a previous request, the service ignores the request, but doesn't return an error. For more information, see Ensuring idempotency.
    ///   - credentialProviderConfigurations: The credential provider configurations for the target. These configurations specify how the gateway authenticates with the target endpoint.
    ///   - description: The description of the gateway target.
    ///   - gatewayIdentifier: The identifier of the gateway to create a target for.
    ///   - name: The name of the gateway target. The name must be unique within the gateway.
    ///   - targetConfiguration: The configuration settings for the target, including endpoint information and schema definitions.
    ///   - logger: Logger use during operation
    @inlinable
    public func createGatewayTarget(
        clientToken: String? = CreateGatewayTargetRequest.idempotencyToken(),
        credentialProviderConfigurations: [CredentialProviderConfiguration]? = nil,
        description: String? = nil,
        gatewayIdentifier: String,
        name: String,
        targetConfiguration: TargetConfiguration,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateGatewayTargetResponse {
        let input = CreateGatewayTargetRequest(
            clientToken: clientToken, 
            credentialProviderConfigurations: credentialProviderConfigurations, 
            description: description, 
            gatewayIdentifier: gatewayIdentifier, 
            name: name, 
            targetConfiguration: targetConfiguration
        )
        return try await self.createGatewayTarget(input, logger: logger)
    }

    /// Creates a new Amazon Bedrock AgentCore Memory resource.
    @Sendable
    @inlinable
    public func createMemory(_ input: CreateMemoryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMemoryOutput {
        try await self.client.execute(
            operation: "CreateMemory", 
            path: "/memories/create", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new Amazon Bedrock AgentCore Memory resource.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier to ensure that the operation completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request but does not return an error.
    ///   - description: The description of the memory.
    ///   - encryptionKeyArn: The Amazon Resource Name (ARN) of the KMS key used to encrypt the memory data.
    ///   - eventExpiryDuration: The duration after which memory events expire. Specified as an ISO 8601 duration.
    ///   - memoryExecutionRoleArn: The Amazon Resource Name (ARN) of the IAM role that provides permissions for the memory to access Amazon Web Services services.
    ///   - memoryStrategies: The memory strategies to use for this memory. Strategies define how information is extracted, processed, and consolidated.
    ///   - name: The name of the memory. The name must be unique within your account.
    ///   - tags: A map of tag keys and values to assign to an AgentCore Memory. Tags enable you to categorize your resources in different ways, for example, by purpose, owner, or environment.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMemory(
        clientToken: String? = CreateMemoryInput.idempotencyToken(),
        description: String? = nil,
        encryptionKeyArn: String? = nil,
        eventExpiryDuration: Int,
        memoryExecutionRoleArn: String? = nil,
        memoryStrategies: [MemoryStrategyInput]? = nil,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMemoryOutput {
        let input = CreateMemoryInput(
            clientToken: clientToken, 
            description: description, 
            encryptionKeyArn: encryptionKeyArn, 
            eventExpiryDuration: eventExpiryDuration, 
            memoryExecutionRoleArn: memoryExecutionRoleArn, 
            memoryStrategies: memoryStrategies, 
            name: name, 
            tags: tags
        )
        return try await self.createMemory(input, logger: logger)
    }

    /// Creates a new OAuth2 credential provider.
    @Sendable
    @inlinable
    public func createOauth2CredentialProvider(_ input: CreateOauth2CredentialProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateOauth2CredentialProviderResponse {
        try await self.client.execute(
            operation: "CreateOauth2CredentialProvider", 
            path: "/identities/CreateOauth2CredentialProvider", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new OAuth2 credential provider.
    ///
    /// Parameters:
    ///   - credentialProviderVendor: The vendor of the OAuth2 credential provider. This specifies which OAuth2 implementation to use.
    ///   - name: The name of the OAuth2 credential provider. The name must be unique within your account.
    ///   - oauth2ProviderConfigInput: The configuration settings for the OAuth2 provider, including client ID, client secret, and other vendor-specific settings.
    ///   - tags: A map of tag keys and values to assign to the OAuth2 credential provider. Tags enable you to categorize your resources in different ways, for example, by purpose, owner, or environment.
    ///   - logger: Logger use during operation
    @inlinable
    public func createOauth2CredentialProvider(
        credentialProviderVendor: CredentialProviderVendorType,
        name: String,
        oauth2ProviderConfigInput: Oauth2ProviderConfigInput,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateOauth2CredentialProviderResponse {
        let input = CreateOauth2CredentialProviderRequest(
            credentialProviderVendor: credentialProviderVendor, 
            name: name, 
            oauth2ProviderConfigInput: oauth2ProviderConfigInput, 
            tags: tags
        )
        return try await self.createOauth2CredentialProvider(input, logger: logger)
    }

    /// Creates a new workload identity.
    @Sendable
    @inlinable
    public func createWorkloadIdentity(_ input: CreateWorkloadIdentityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWorkloadIdentityResponse {
        try await self.client.execute(
            operation: "CreateWorkloadIdentity", 
            path: "/identities/CreateWorkloadIdentity", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new workload identity.
    ///
    /// Parameters:
    ///   - allowedResourceOauth2ReturnUrls: The list of allowed OAuth2 return URLs for resources associated with this workload identity.
    ///   - name: The name of the workload identity. The name must be unique within your account.
    ///   - tags: A map of tag keys and values to assign to the workload identity. Tags enable you to categorize your resources in different ways, for example, by purpose, owner, or environment.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWorkloadIdentity(
        allowedResourceOauth2ReturnUrls: [String]? = nil,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWorkloadIdentityResponse {
        let input = CreateWorkloadIdentityRequest(
            allowedResourceOauth2ReturnUrls: allowedResourceOauth2ReturnUrls, 
            name: name, 
            tags: tags
        )
        return try await self.createWorkloadIdentity(input, logger: logger)
    }

    /// Deletes an Amazon Bedrock AgentCore Runtime.
    @Sendable
    @inlinable
    public func deleteAgentRuntime(_ input: DeleteAgentRuntimeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAgentRuntimeResponse {
        try await self.client.execute(
            operation: "DeleteAgentRuntime", 
            path: "/runtimes/{agentRuntimeId}/", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Bedrock AgentCore Runtime.
    ///
    /// Parameters:
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAgentRuntime(
        agentRuntimeId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAgentRuntimeResponse {
        let input = DeleteAgentRuntimeRequest(
            agentRuntimeId: agentRuntimeId
        )
        return try await self.deleteAgentRuntime(input, logger: logger)
    }

    /// Deletes an AAgentCore Runtime endpoint.
    @Sendable
    @inlinable
    public func deleteAgentRuntimeEndpoint(_ input: DeleteAgentRuntimeEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAgentRuntimeEndpointResponse {
        try await self.client.execute(
            operation: "DeleteAgentRuntimeEndpoint", 
            path: "/runtimes/{agentRuntimeId}/runtime-endpoints/{endpointName}/", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an AAgentCore Runtime endpoint.
    ///
    /// Parameters:
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime associated with the endpoint.
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - endpointName: The name of the AgentCore Runtime endpoint to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAgentRuntimeEndpoint(
        agentRuntimeId: String,
        clientToken: String? = DeleteAgentRuntimeEndpointRequest.idempotencyToken(),
        endpointName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAgentRuntimeEndpointResponse {
        let input = DeleteAgentRuntimeEndpointRequest(
            agentRuntimeId: agentRuntimeId, 
            clientToken: clientToken, 
            endpointName: endpointName
        )
        return try await self.deleteAgentRuntimeEndpoint(input, logger: logger)
    }

    /// Deletes an API key credential provider.
    @Sendable
    @inlinable
    public func deleteApiKeyCredentialProvider(_ input: DeleteApiKeyCredentialProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteApiKeyCredentialProviderResponse {
        try await self.client.execute(
            operation: "DeleteApiKeyCredentialProvider", 
            path: "/identities/DeleteApiKeyCredentialProvider", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an API key credential provider.
    ///
    /// Parameters:
    ///   - name: The name of the API key credential provider to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteApiKeyCredentialProvider(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteApiKeyCredentialProviderResponse {
        let input = DeleteApiKeyCredentialProviderRequest(
            name: name
        )
        return try await self.deleteApiKeyCredentialProvider(input, logger: logger)
    }

    /// Deletes a custom browser.
    @Sendable
    @inlinable
    public func deleteBrowser(_ input: DeleteBrowserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteBrowserResponse {
        try await self.client.execute(
            operation: "DeleteBrowser", 
            path: "/browsers/{browserId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a custom browser.
    ///
    /// Parameters:
    ///   - browserId: The unique identifier of the browser to delete.
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteBrowser(
        browserId: String,
        clientToken: String? = DeleteBrowserRequest.idempotencyToken(),
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteBrowserResponse {
        let input = DeleteBrowserRequest(
            browserId: browserId, 
            clientToken: clientToken
        )
        return try await self.deleteBrowser(input, logger: logger)
    }

    /// Deletes a custom code interpreter.
    @Sendable
    @inlinable
    public func deleteCodeInterpreter(_ input: DeleteCodeInterpreterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCodeInterpreterResponse {
        try await self.client.execute(
            operation: "DeleteCodeInterpreter", 
            path: "/code-interpreters/{codeInterpreterId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a custom code interpreter.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - codeInterpreterId: The unique identifier of the code interpreter to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCodeInterpreter(
        clientToken: String? = DeleteCodeInterpreterRequest.idempotencyToken(),
        codeInterpreterId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCodeInterpreterResponse {
        let input = DeleteCodeInterpreterRequest(
            clientToken: clientToken, 
            codeInterpreterId: codeInterpreterId
        )
        return try await self.deleteCodeInterpreter(input, logger: logger)
    }

    /// Deletes a gateway.
    @Sendable
    @inlinable
    public func deleteGateway(_ input: DeleteGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteGatewayResponse {
        try await self.client.execute(
            operation: "DeleteGateway", 
            path: "/gateways/{gatewayIdentifier}/", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a gateway.
    ///
    /// Parameters:
    ///   - gatewayIdentifier: The identifier of the gateway to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteGateway(
        gatewayIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteGatewayResponse {
        let input = DeleteGatewayRequest(
            gatewayIdentifier: gatewayIdentifier
        )
        return try await self.deleteGateway(input, logger: logger)
    }

    /// Deletes a gateway target.
    @Sendable
    @inlinable
    public func deleteGatewayTarget(_ input: DeleteGatewayTargetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteGatewayTargetResponse {
        try await self.client.execute(
            operation: "DeleteGatewayTarget", 
            path: "/gateways/{gatewayIdentifier}/targets/{targetId}/", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a gateway target.
    ///
    /// Parameters:
    ///   - gatewayIdentifier: The unique identifier of the gateway associated with the target.
    ///   - targetId: The unique identifier of the gateway target to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteGatewayTarget(
        gatewayIdentifier: String,
        targetId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteGatewayTargetResponse {
        let input = DeleteGatewayTargetRequest(
            gatewayIdentifier: gatewayIdentifier, 
            targetId: targetId
        )
        return try await self.deleteGatewayTarget(input, logger: logger)
    }

    /// Deletes an Amazon Bedrock AgentCore Memory resource.
    @Sendable
    @inlinable
    public func deleteMemory(_ input: DeleteMemoryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteMemoryOutput {
        try await self.client.execute(
            operation: "DeleteMemory", 
            path: "/memories/{memoryId}/delete", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Bedrock AgentCore Memory resource.
    ///
    /// Parameters:
    ///   - clientToken: A client token is used for keeping track of idempotent requests. It can contain a session id which can be around 250 chars, combined with a unique AWS identifier.
    ///   - memoryId: The unique identifier of the memory to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMemory(
        clientToken: String? = DeleteMemoryInput.idempotencyToken(),
        memoryId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteMemoryOutput {
        let input = DeleteMemoryInput(
            clientToken: clientToken, 
            memoryId: memoryId
        )
        return try await self.deleteMemory(input, logger: logger)
    }

    /// Deletes an OAuth2 credential provider.
    @Sendable
    @inlinable
    public func deleteOauth2CredentialProvider(_ input: DeleteOauth2CredentialProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteOauth2CredentialProviderResponse {
        try await self.client.execute(
            operation: "DeleteOauth2CredentialProvider", 
            path: "/identities/DeleteOauth2CredentialProvider", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an OAuth2 credential provider.
    ///
    /// Parameters:
    ///   - name: The name of the OAuth2 credential provider to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteOauth2CredentialProvider(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteOauth2CredentialProviderResponse {
        let input = DeleteOauth2CredentialProviderRequest(
            name: name
        )
        return try await self.deleteOauth2CredentialProvider(input, logger: logger)
    }

    /// Deletes a workload identity.
    @Sendable
    @inlinable
    public func deleteWorkloadIdentity(_ input: DeleteWorkloadIdentityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteWorkloadIdentityResponse {
        try await self.client.execute(
            operation: "DeleteWorkloadIdentity", 
            path: "/identities/DeleteWorkloadIdentity", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a workload identity.
    ///
    /// Parameters:
    ///   - name: The name of the workload identity to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWorkloadIdentity(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteWorkloadIdentityResponse {
        let input = DeleteWorkloadIdentityRequest(
            name: name
        )
        return try await self.deleteWorkloadIdentity(input, logger: logger)
    }

    /// Gets an Amazon Bedrock AgentCore Runtime.
    @Sendable
    @inlinable
    public func getAgentRuntime(_ input: GetAgentRuntimeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAgentRuntimeResponse {
        try await self.client.execute(
            operation: "GetAgentRuntime", 
            path: "/runtimes/{agentRuntimeId}/", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an Amazon Bedrock AgentCore Runtime.
    ///
    /// Parameters:
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime to retrieve.
    ///   - agentRuntimeVersion: The version of the AgentCore Runtime to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAgentRuntime(
        agentRuntimeId: String,
        agentRuntimeVersion: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAgentRuntimeResponse {
        let input = GetAgentRuntimeRequest(
            agentRuntimeId: agentRuntimeId, 
            agentRuntimeVersion: agentRuntimeVersion
        )
        return try await self.getAgentRuntime(input, logger: logger)
    }

    /// Gets information about an Amazon Secure AgentEndpoint.
    @Sendable
    @inlinable
    public func getAgentRuntimeEndpoint(_ input: GetAgentRuntimeEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAgentRuntimeEndpointResponse {
        try await self.client.execute(
            operation: "GetAgentRuntimeEndpoint", 
            path: "/runtimes/{agentRuntimeId}/runtime-endpoints/{endpointName}/", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about an Amazon Secure AgentEndpoint.
    ///
    /// Parameters:
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime associated with the endpoint.
    ///   - endpointName: The name of the AgentCore Runtime endpoint to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAgentRuntimeEndpoint(
        agentRuntimeId: String,
        endpointName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAgentRuntimeEndpointResponse {
        let input = GetAgentRuntimeEndpointRequest(
            agentRuntimeId: agentRuntimeId, 
            endpointName: endpointName
        )
        return try await self.getAgentRuntimeEndpoint(input, logger: logger)
    }

    /// Retrieves information about an API key credential provider.
    @Sendable
    @inlinable
    public func getApiKeyCredentialProvider(_ input: GetApiKeyCredentialProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetApiKeyCredentialProviderResponse {
        try await self.client.execute(
            operation: "GetApiKeyCredentialProvider", 
            path: "/identities/GetApiKeyCredentialProvider", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about an API key credential provider.
    ///
    /// Parameters:
    ///   - name: The name of the API key credential provider to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApiKeyCredentialProvider(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetApiKeyCredentialProviderResponse {
        let input = GetApiKeyCredentialProviderRequest(
            name: name
        )
        return try await self.getApiKeyCredentialProvider(input, logger: logger)
    }

    /// Gets information about a custom browser.
    @Sendable
    @inlinable
    public func getBrowser(_ input: GetBrowserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetBrowserResponse {
        try await self.client.execute(
            operation: "GetBrowser", 
            path: "/browsers/{browserId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a custom browser.
    ///
    /// Parameters:
    ///   - browserId: The unique identifier of the browser to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getBrowser(
        browserId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetBrowserResponse {
        let input = GetBrowserRequest(
            browserId: browserId
        )
        return try await self.getBrowser(input, logger: logger)
    }

    /// Gets information about a custom code interpreter.
    @Sendable
    @inlinable
    public func getCodeInterpreter(_ input: GetCodeInterpreterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCodeInterpreterResponse {
        try await self.client.execute(
            operation: "GetCodeInterpreter", 
            path: "/code-interpreters/{codeInterpreterId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a custom code interpreter.
    ///
    /// Parameters:
    ///   - codeInterpreterId: The unique identifier of the code interpreter to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCodeInterpreter(
        codeInterpreterId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCodeInterpreterResponse {
        let input = GetCodeInterpreterRequest(
            codeInterpreterId: codeInterpreterId
        )
        return try await self.getCodeInterpreter(input, logger: logger)
    }

    /// Retrieves information about a specific Gateway.
    @Sendable
    @inlinable
    public func getGateway(_ input: GetGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetGatewayResponse {
        try await self.client.execute(
            operation: "GetGateway", 
            path: "/gateways/{gatewayIdentifier}/", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a specific Gateway.
    ///
    /// Parameters:
    ///   - gatewayIdentifier: The identifier of the gateway to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getGateway(
        gatewayIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetGatewayResponse {
        let input = GetGatewayRequest(
            gatewayIdentifier: gatewayIdentifier
        )
        return try await self.getGateway(input, logger: logger)
    }

    /// Retrieves information about a specific gateway target.
    @Sendable
    @inlinable
    public func getGatewayTarget(_ input: GetGatewayTargetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetGatewayTargetResponse {
        try await self.client.execute(
            operation: "GetGatewayTarget", 
            path: "/gateways/{gatewayIdentifier}/targets/{targetId}/", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a specific gateway target.
    ///
    /// Parameters:
    ///   - gatewayIdentifier: The identifier of the gateway that contains the target.
    ///   - targetId: The unique identifier of the target to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getGatewayTarget(
        gatewayIdentifier: String,
        targetId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetGatewayTargetResponse {
        let input = GetGatewayTargetRequest(
            gatewayIdentifier: gatewayIdentifier, 
            targetId: targetId
        )
        return try await self.getGatewayTarget(input, logger: logger)
    }

    /// Retrieve an existing Amazon Bedrock AgentCore Memory resource.
    @Sendable
    @inlinable
    public func getMemory(_ input: GetMemoryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMemoryOutput {
        try await self.client.execute(
            operation: "GetMemory", 
            path: "/memories/{memoryId}/details", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieve an existing Amazon Bedrock AgentCore Memory resource.
    ///
    /// Parameters:
    ///   - memoryId: The unique identifier of the memory to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMemory(
        memoryId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMemoryOutput {
        let input = GetMemoryInput(
            memoryId: memoryId
        )
        return try await self.getMemory(input, logger: logger)
    }

    /// Retrieves information about an OAuth2 credential provider.
    @Sendable
    @inlinable
    public func getOauth2CredentialProvider(_ input: GetOauth2CredentialProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOauth2CredentialProviderResponse {
        try await self.client.execute(
            operation: "GetOauth2CredentialProvider", 
            path: "/identities/GetOauth2CredentialProvider", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about an OAuth2 credential provider.
    ///
    /// Parameters:
    ///   - name: The name of the OAuth2 credential provider to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOauth2CredentialProvider(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOauth2CredentialProviderResponse {
        let input = GetOauth2CredentialProviderRequest(
            name: name
        )
        return try await self.getOauth2CredentialProvider(input, logger: logger)
    }

    /// Retrieves information about a token vault.
    @Sendable
    @inlinable
    public func getTokenVault(_ input: GetTokenVaultRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTokenVaultResponse {
        try await self.client.execute(
            operation: "GetTokenVault", 
            path: "/identities/get-token-vault", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a token vault.
    ///
    /// Parameters:
    ///   - tokenVaultId: The unique identifier of the token vault to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTokenVault(
        tokenVaultId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTokenVaultResponse {
        let input = GetTokenVaultRequest(
            tokenVaultId: tokenVaultId
        )
        return try await self.getTokenVault(input, logger: logger)
    }

    /// Retrieves information about a workload identity.
    @Sendable
    @inlinable
    public func getWorkloadIdentity(_ input: GetWorkloadIdentityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWorkloadIdentityResponse {
        try await self.client.execute(
            operation: "GetWorkloadIdentity", 
            path: "/identities/GetWorkloadIdentity", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a workload identity.
    ///
    /// Parameters:
    ///   - name: The name of the workload identity to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWorkloadIdentity(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWorkloadIdentityResponse {
        let input = GetWorkloadIdentityRequest(
            name: name
        )
        return try await self.getWorkloadIdentity(input, logger: logger)
    }

    /// Lists all endpoints for a specific Amazon Secure Agent.
    @Sendable
    @inlinable
    public func listAgentRuntimeEndpoints(_ input: ListAgentRuntimeEndpointsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAgentRuntimeEndpointsResponse {
        try await self.client.execute(
            operation: "ListAgentRuntimeEndpoints", 
            path: "/runtimes/{agentRuntimeId}/runtime-endpoints/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all endpoints for a specific Amazon Secure Agent.
    ///
    /// Parameters:
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime to list endpoints for.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: A token to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAgentRuntimeEndpoints(
        agentRuntimeId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAgentRuntimeEndpointsResponse {
        let input = ListAgentRuntimeEndpointsRequest(
            agentRuntimeId: agentRuntimeId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAgentRuntimeEndpoints(input, logger: logger)
    }

    /// Lists all versions of a specific Amazon Secure Agent.
    @Sendable
    @inlinable
    public func listAgentRuntimeVersions(_ input: ListAgentRuntimeVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAgentRuntimeVersionsResponse {
        try await self.client.execute(
            operation: "ListAgentRuntimeVersions", 
            path: "/runtimes/{agentRuntimeId}/versions/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all versions of a specific Amazon Secure Agent.
    ///
    /// Parameters:
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime to list versions for.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: A token to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAgentRuntimeVersions(
        agentRuntimeId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAgentRuntimeVersionsResponse {
        let input = ListAgentRuntimeVersionsRequest(
            agentRuntimeId: agentRuntimeId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAgentRuntimeVersions(input, logger: logger)
    }

    /// Lists all Amazon Secure Agents in your account.
    @Sendable
    @inlinable
    public func listAgentRuntimes(_ input: ListAgentRuntimesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAgentRuntimesResponse {
        try await self.client.execute(
            operation: "ListAgentRuntimes", 
            path: "/runtimes/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all Amazon Secure Agents in your account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: A token to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAgentRuntimes(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAgentRuntimesResponse {
        let input = ListAgentRuntimesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAgentRuntimes(input, logger: logger)
    }

    /// Lists all API key credential providers in your account.
    @Sendable
    @inlinable
    public func listApiKeyCredentialProviders(_ input: ListApiKeyCredentialProvidersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListApiKeyCredentialProvidersResponse {
        try await self.client.execute(
            operation: "ListApiKeyCredentialProviders", 
            path: "/identities/ListApiKeyCredentialProviders", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all API key credential providers in your account.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of results to return.
    ///   - nextToken: Pagination token.
    ///   - logger: Logger use during operation
    @inlinable
    public func listApiKeyCredentialProviders(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListApiKeyCredentialProvidersResponse {
        let input = ListApiKeyCredentialProvidersRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listApiKeyCredentialProviders(input, logger: logger)
    }

    /// Lists all custom browsers in your account.
    @Sendable
    @inlinable
    public func listBrowsers(_ input: ListBrowsersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListBrowsersResponse {
        try await self.client.execute(
            operation: "ListBrowsers", 
            path: "/browsers", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all custom browsers in your account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. The default value is 10. The maximum value is 50.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - type: The type of browsers to list. If not specified, all browser types are returned.
    ///   - logger: Logger use during operation
    @inlinable
    public func listBrowsers(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        type: ResourceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBrowsersResponse {
        let input = ListBrowsersRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            type: type
        )
        return try await self.listBrowsers(input, logger: logger)
    }

    /// Lists all custom code interpreters in your account.
    @Sendable
    @inlinable
    public func listCodeInterpreters(_ input: ListCodeInterpretersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCodeInterpretersResponse {
        try await self.client.execute(
            operation: "ListCodeInterpreters", 
            path: "/code-interpreters", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all custom code interpreters in your account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: A token to retrieve the next page of results.
    ///   - type: The type of code interpreters to list.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCodeInterpreters(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        type: ResourceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCodeInterpretersResponse {
        let input = ListCodeInterpretersRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            type: type
        )
        return try await self.listCodeInterpreters(input, logger: logger)
    }

    /// Lists all targets for a specific gateway.
    @Sendable
    @inlinable
    public func listGatewayTargets(_ input: ListGatewayTargetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListGatewayTargetsResponse {
        try await self.client.execute(
            operation: "ListGatewayTargets", 
            path: "/gateways/{gatewayIdentifier}/targets/", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all targets for a specific gateway.
    ///
    /// Parameters:
    ///   - gatewayIdentifier: The identifier of the gateway to list targets for.
    ///   - maxResults: The maximum number of results to return in the response. If the total number of results is greater than this value, use the token returned in the response in the nextToken field when making another request to return the next batch of results.
    ///   - nextToken: If the total number of results is greater than the maxResults value provided in the request, enter the token returned in the nextToken field in the response in this field to return the next batch of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listGatewayTargets(
        gatewayIdentifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListGatewayTargetsResponse {
        let input = ListGatewayTargetsRequest(
            gatewayIdentifier: gatewayIdentifier, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listGatewayTargets(input, logger: logger)
    }

    /// Lists all gateways in the account.
    @Sendable
    @inlinable
    public func listGateways(_ input: ListGatewaysRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListGatewaysResponse {
        try await self.client.execute(
            operation: "ListGateways", 
            path: "/gateways/", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all gateways in the account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in the response. If the total number of results is greater than this value, use the token returned in the response in the nextToken field when making another request to return the next batch of results.
    ///   - nextToken: If the total number of results is greater than the maxResults value provided in the request, enter the token returned in the nextToken field in the response in this field to return the next batch of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listGateways(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListGatewaysResponse {
        let input = ListGatewaysRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listGateways(input, logger: logger)
    }

    /// Lists the available Amazon Bedrock AgentCore Memory resources in the current Amazon Web Services Region.
    @Sendable
    @inlinable
    public func listMemories(_ input: ListMemoriesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMemoriesOutput {
        try await self.client.execute(
            operation: "ListMemories", 
            path: "/memories/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the available Amazon Bedrock AgentCore Memory resources in the current Amazon Web Services Region.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. The default value is 10. The maximum value is 50.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMemories(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMemoriesOutput {
        let input = ListMemoriesInput(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMemories(input, logger: logger)
    }

    /// Lists all OAuth2 credential providers in your account.
    @Sendable
    @inlinable
    public func listOauth2CredentialProviders(_ input: ListOauth2CredentialProvidersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOauth2CredentialProvidersResponse {
        try await self.client.execute(
            operation: "ListOauth2CredentialProviders", 
            path: "/identities/ListOauth2CredentialProviders", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all OAuth2 credential providers in your account.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of results to return.
    ///   - nextToken: Pagination token.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOauth2CredentialProviders(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOauth2CredentialProvidersResponse {
        let input = ListOauth2CredentialProvidersRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listOauth2CredentialProviders(input, logger: logger)
    }

    /// Lists the tags associated with the specified resource.  This feature is currently available only for AgentCore Runtime, Browser, Code Interpreter tool, and Gateway.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags associated with the specified resource.  This feature is currently available only for AgentCore Runtime, Browser, Code Interpreter tool, and Gateway.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource for which you want to list tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Lists all workload identities in your account.
    @Sendable
    @inlinable
    public func listWorkloadIdentities(_ input: ListWorkloadIdentitiesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWorkloadIdentitiesResponse {
        try await self.client.execute(
            operation: "ListWorkloadIdentities", 
            path: "/identities/ListWorkloadIdentities", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all workload identities in your account.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of results to return.
    ///   - nextToken: Pagination token.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWorkloadIdentities(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWorkloadIdentitiesResponse {
        let input = ListWorkloadIdentitiesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listWorkloadIdentities(input, logger: logger)
    }

    /// Sets the customer master key (CMK) for a token vault.
    @Sendable
    @inlinable
    public func setTokenVaultCMK(_ input: SetTokenVaultCMKRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SetTokenVaultCMKResponse {
        try await self.client.execute(
            operation: "SetTokenVaultCMK", 
            path: "/identities/set-token-vault-cmk", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sets the customer master key (CMK) for a token vault.
    ///
    /// Parameters:
    ///   - kmsConfiguration: The KMS configuration for the token vault, including the key type and KMS key ARN.
    ///   - tokenVaultId: The unique identifier of the token vault to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func setTokenVaultCMK(
        kmsConfiguration: KmsConfiguration,
        tokenVaultId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SetTokenVaultCMKResponse {
        let input = SetTokenVaultCMKRequest(
            kmsConfiguration: kmsConfiguration, 
            tokenVaultId: tokenVaultId
        )
        return try await self.setTokenVaultCMK(input, logger: logger)
    }

    /// The gateway targets.
    @Sendable
    @inlinable
    public func synchronizeGatewayTargets(_ input: SynchronizeGatewayTargetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SynchronizeGatewayTargetsResponse {
        try await self.client.execute(
            operation: "SynchronizeGatewayTargets", 
            path: "/gateways/{gatewayIdentifier}/synchronizeTargets", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// The gateway targets.
    ///
    /// Parameters:
    ///   - gatewayIdentifier: The gateway Identifier.
    ///   - targetIdList: The target ID list.
    ///   - logger: Logger use during operation
    @inlinable
    public func synchronizeGatewayTargets(
        gatewayIdentifier: String,
        targetIdList: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SynchronizeGatewayTargetsResponse {
        let input = SynchronizeGatewayTargetsRequest(
            gatewayIdentifier: gatewayIdentifier, 
            targetIdList: targetIdList
        )
        return try await self.synchronizeGatewayTargets(input, logger: logger)
    }

    /// Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags associated with that resource are also deleted.  This feature is currently available only for AgentCore Runtime, Browser, Code Interpreter tool, and Gateway.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags associated with that resource are also deleted.  This feature is currently available only for AgentCore Runtime, Browser, Code Interpreter tool, and Gateway.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource that you want to tag.
    ///   - tags: The tags to add to the resource. A tag is a key-value pair.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes the specified tags from the specified resource.  This feature is currently available only for AgentCore Runtime, Browser, Code Interpreter tool, and Gateway.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified tags from the specified resource.  This feature is currently available only for AgentCore Runtime, Browser, Code Interpreter tool, and Gateway.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource that you want to untag.
    ///   - tagKeys: The tag keys of the tags to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates an existing Amazon Secure Agent.
    @Sendable
    @inlinable
    public func updateAgentRuntime(_ input: UpdateAgentRuntimeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAgentRuntimeResponse {
        try await self.client.execute(
            operation: "UpdateAgentRuntime", 
            path: "/runtimes/{agentRuntimeId}/", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing Amazon Secure Agent.
    ///
    /// Parameters:
    ///   - agentRuntimeArtifact: The updated artifact of the AgentCore Runtime.
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime to update.
    ///   - authorizerConfiguration: The updated authorizer configuration for the AgentCore Runtime.
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: The updated description of the AgentCore Runtime.
    ///   - environmentVariables: Updated environment variables to set in the AgentCore Runtime environment.
    ///   - lifecycleConfiguration: The updated life cycle configuration for the AgentCore Runtime.
    ///   - networkConfiguration: The updated network configuration for the AgentCore Runtime.
    ///   - protocolConfiguration: 
    ///   - requestHeaderConfiguration: The updated configuration for HTTP request headers that will be passed through to the runtime.
    ///   - roleArn: The updated IAM role ARN that provides permissions for the AgentCore Runtime.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAgentRuntime(
        agentRuntimeArtifact: AgentRuntimeArtifact,
        agentRuntimeId: String,
        authorizerConfiguration: AuthorizerConfiguration? = nil,
        clientToken: String? = UpdateAgentRuntimeRequest.idempotencyToken(),
        description: String? = nil,
        environmentVariables: [String: String]? = nil,
        lifecycleConfiguration: LifecycleConfiguration? = nil,
        networkConfiguration: NetworkConfiguration,
        protocolConfiguration: ProtocolConfiguration? = nil,
        requestHeaderConfiguration: RequestHeaderConfiguration? = nil,
        roleArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAgentRuntimeResponse {
        let input = UpdateAgentRuntimeRequest(
            agentRuntimeArtifact: agentRuntimeArtifact, 
            agentRuntimeId: agentRuntimeId, 
            authorizerConfiguration: authorizerConfiguration, 
            clientToken: clientToken, 
            description: description, 
            environmentVariables: environmentVariables, 
            lifecycleConfiguration: lifecycleConfiguration, 
            networkConfiguration: networkConfiguration, 
            protocolConfiguration: protocolConfiguration, 
            requestHeaderConfiguration: requestHeaderConfiguration, 
            roleArn: roleArn
        )
        return try await self.updateAgentRuntime(input, logger: logger)
    }

    /// Updates an existing Amazon Bedrock AgentCore Runtime endpoint.
    @Sendable
    @inlinable
    public func updateAgentRuntimeEndpoint(_ input: UpdateAgentRuntimeEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAgentRuntimeEndpointResponse {
        try await self.client.execute(
            operation: "UpdateAgentRuntimeEndpoint", 
            path: "/runtimes/{agentRuntimeId}/runtime-endpoints/{endpointName}/", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing Amazon Bedrock AgentCore Runtime endpoint.
    ///
    /// Parameters:
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime associated with the endpoint.
    ///   - agentRuntimeVersion: The updated version of the AgentCore Runtime for the endpoint.
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: The updated description of the AgentCore Runtime endpoint.
    ///   - endpointName: The name of the AgentCore Runtime endpoint to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAgentRuntimeEndpoint(
        agentRuntimeId: String,
        agentRuntimeVersion: String? = nil,
        clientToken: String? = UpdateAgentRuntimeEndpointRequest.idempotencyToken(),
        description: String? = nil,
        endpointName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAgentRuntimeEndpointResponse {
        let input = UpdateAgentRuntimeEndpointRequest(
            agentRuntimeId: agentRuntimeId, 
            agentRuntimeVersion: agentRuntimeVersion, 
            clientToken: clientToken, 
            description: description, 
            endpointName: endpointName
        )
        return try await self.updateAgentRuntimeEndpoint(input, logger: logger)
    }

    /// Updates an existing API key credential provider.
    @Sendable
    @inlinable
    public func updateApiKeyCredentialProvider(_ input: UpdateApiKeyCredentialProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApiKeyCredentialProviderResponse {
        try await self.client.execute(
            operation: "UpdateApiKeyCredentialProvider", 
            path: "/identities/UpdateApiKeyCredentialProvider", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing API key credential provider.
    ///
    /// Parameters:
    ///   - apiKey: The new API key to use for authentication. This value replaces the existing API key and is encrypted and stored securely.
    ///   - name: The name of the API key credential provider to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApiKeyCredentialProvider(
        apiKey: String,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApiKeyCredentialProviderResponse {
        let input = UpdateApiKeyCredentialProviderRequest(
            apiKey: apiKey, 
            name: name
        )
        return try await self.updateApiKeyCredentialProvider(input, logger: logger)
    }

    /// Updates an existing gateway.
    @Sendable
    @inlinable
    public func updateGateway(_ input: UpdateGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateGatewayResponse {
        try await self.client.execute(
            operation: "UpdateGateway", 
            path: "/gateways/{gatewayIdentifier}/", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing gateway.
    ///
    /// Parameters:
    ///   - authorizerConfiguration: The updated authorizer configuration for the gateway.
    ///   - authorizerType: The updated authorizer type for the gateway.
    ///   - description: The updated description for the gateway.
    ///   - exceptionLevel: The level of detail in error messages returned when invoking the gateway.   If the value is DEBUG, granular exception messages are returned to help a user debug the gateway.   If the value is omitted, a generic error message is returned to the end user.
    ///   - gatewayIdentifier: The identifier of the gateway to update.
    ///   - kmsKeyArn: The updated ARN of the KMS key used to encrypt the gateway.
    ///   - name: The name of the gateway. This name must be the same as the one when the gateway was created.
    ///   - protocolConfiguration: 
    ///   - protocolType: The updated protocol type for the gateway.
    ///   - roleArn: The updated IAM role ARN that provides permissions for the gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateGateway(
        authorizerConfiguration: AuthorizerConfiguration? = nil,
        authorizerType: AuthorizerType,
        description: String? = nil,
        exceptionLevel: ExceptionLevel? = nil,
        gatewayIdentifier: String,
        kmsKeyArn: String? = nil,
        name: String,
        protocolConfiguration: GatewayProtocolConfiguration? = nil,
        protocolType: GatewayProtocolType,
        roleArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateGatewayResponse {
        let input = UpdateGatewayRequest(
            authorizerConfiguration: authorizerConfiguration, 
            authorizerType: authorizerType, 
            description: description, 
            exceptionLevel: exceptionLevel, 
            gatewayIdentifier: gatewayIdentifier, 
            kmsKeyArn: kmsKeyArn, 
            name: name, 
            protocolConfiguration: protocolConfiguration, 
            protocolType: protocolType, 
            roleArn: roleArn
        )
        return try await self.updateGateway(input, logger: logger)
    }

    /// Updates an existing gateway target.
    @Sendable
    @inlinable
    public func updateGatewayTarget(_ input: UpdateGatewayTargetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateGatewayTargetResponse {
        try await self.client.execute(
            operation: "UpdateGatewayTarget", 
            path: "/gateways/{gatewayIdentifier}/targets/{targetId}/", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing gateway target.
    ///
    /// Parameters:
    ///   - credentialProviderConfigurations: The updated credential provider configurations for the gateway target.
    ///   - description: The updated description for the gateway target.
    ///   - gatewayIdentifier: The unique identifier of the gateway associated with the target.
    ///   - name: The updated name for the gateway target.
    ///   - targetConfiguration: 
    ///   - targetId: The unique identifier of the gateway target to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateGatewayTarget(
        credentialProviderConfigurations: [CredentialProviderConfiguration]? = nil,
        description: String? = nil,
        gatewayIdentifier: String,
        name: String,
        targetConfiguration: TargetConfiguration,
        targetId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateGatewayTargetResponse {
        let input = UpdateGatewayTargetRequest(
            credentialProviderConfigurations: credentialProviderConfigurations, 
            description: description, 
            gatewayIdentifier: gatewayIdentifier, 
            name: name, 
            targetConfiguration: targetConfiguration, 
            targetId: targetId
        )
        return try await self.updateGatewayTarget(input, logger: logger)
    }

    /// Update an Amazon Bedrock AgentCore Memory resource memory.
    @Sendable
    @inlinable
    public func updateMemory(_ input: UpdateMemoryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateMemoryOutput {
        try await self.client.execute(
            operation: "UpdateMemory", 
            path: "/memories/{memoryId}/update", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update an Amazon Bedrock AgentCore Memory resource memory.
    ///
    /// Parameters:
    ///   - clientToken: A client token is used for keeping track of idempotent requests. It can contain a session id which can be around 250 chars, combined with a unique AWS identifier.
    ///   - description: The updated description of the AgentCore Memory resource.
    ///   - eventExpiryDuration: The number of days after which memory events will expire, between 7 and 365 days.
    ///   - memoryExecutionRoleArn: The ARN of the IAM role that provides permissions for the AgentCore Memory resource.
    ///   - memoryId: The unique identifier of the memory to update.
    ///   - memoryStrategies: The memory strategies to add, modify, or delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMemory(
        clientToken: String? = UpdateMemoryInput.idempotencyToken(),
        description: String? = nil,
        eventExpiryDuration: Int? = nil,
        memoryExecutionRoleArn: String? = nil,
        memoryId: String,
        memoryStrategies: ModifyMemoryStrategies? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateMemoryOutput {
        let input = UpdateMemoryInput(
            clientToken: clientToken, 
            description: description, 
            eventExpiryDuration: eventExpiryDuration, 
            memoryExecutionRoleArn: memoryExecutionRoleArn, 
            memoryId: memoryId, 
            memoryStrategies: memoryStrategies
        )
        return try await self.updateMemory(input, logger: logger)
    }

    /// Updates an existing OAuth2 credential provider.
    @Sendable
    @inlinable
    public func updateOauth2CredentialProvider(_ input: UpdateOauth2CredentialProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateOauth2CredentialProviderResponse {
        try await self.client.execute(
            operation: "UpdateOauth2CredentialProvider", 
            path: "/identities/UpdateOauth2CredentialProvider", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing OAuth2 credential provider.
    ///
    /// Parameters:
    ///   - credentialProviderVendor: The vendor of the OAuth2 credential provider.
    ///   - name: The name of the OAuth2 credential provider to update.
    ///   - oauth2ProviderConfigInput: The configuration input for the OAuth2 provider.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateOauth2CredentialProvider(
        credentialProviderVendor: CredentialProviderVendorType,
        name: String,
        oauth2ProviderConfigInput: Oauth2ProviderConfigInput,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateOauth2CredentialProviderResponse {
        let input = UpdateOauth2CredentialProviderRequest(
            credentialProviderVendor: credentialProviderVendor, 
            name: name, 
            oauth2ProviderConfigInput: oauth2ProviderConfigInput
        )
        return try await self.updateOauth2CredentialProvider(input, logger: logger)
    }

    /// Updates an existing workload identity.
    @Sendable
    @inlinable
    public func updateWorkloadIdentity(_ input: UpdateWorkloadIdentityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateWorkloadIdentityResponse {
        try await self.client.execute(
            operation: "UpdateWorkloadIdentity", 
            path: "/identities/UpdateWorkloadIdentity", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing workload identity.
    ///
    /// Parameters:
    ///   - allowedResourceOauth2ReturnUrls: The new list of allowed OAuth2 return URLs for resources associated with this workload identity. This list replaces the existing list.
    ///   - name: The name of the workload identity to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateWorkloadIdentity(
        allowedResourceOauth2ReturnUrls: [String]? = nil,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateWorkloadIdentityResponse {
        let input = UpdateWorkloadIdentityRequest(
            allowedResourceOauth2ReturnUrls: allowedResourceOauth2ReturnUrls, 
            name: name
        )
        return try await self.updateWorkloadIdentity(input, logger: logger)
    }
}

extension BedrockAgentCoreControl {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: BedrockAgentCoreControl, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension BedrockAgentCoreControl {
    /// Return PaginatorSequence for operation ``listAgentRuntimeEndpoints(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAgentRuntimeEndpointsPaginator(
        _ input: ListAgentRuntimeEndpointsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAgentRuntimeEndpointsRequest, ListAgentRuntimeEndpointsResponse> {
        return .init(
            input: input,
            command: self.listAgentRuntimeEndpoints,
            inputKey: \ListAgentRuntimeEndpointsRequest.nextToken,
            outputKey: \ListAgentRuntimeEndpointsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAgentRuntimeEndpoints(_:logger:)``.
    ///
    /// - Parameters:
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime to list endpoints for.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAgentRuntimeEndpointsPaginator(
        agentRuntimeId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAgentRuntimeEndpointsRequest, ListAgentRuntimeEndpointsResponse> {
        let input = ListAgentRuntimeEndpointsRequest(
            agentRuntimeId: agentRuntimeId, 
            maxResults: maxResults
        )
        return self.listAgentRuntimeEndpointsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAgentRuntimeVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAgentRuntimeVersionsPaginator(
        _ input: ListAgentRuntimeVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAgentRuntimeVersionsRequest, ListAgentRuntimeVersionsResponse> {
        return .init(
            input: input,
            command: self.listAgentRuntimeVersions,
            inputKey: \ListAgentRuntimeVersionsRequest.nextToken,
            outputKey: \ListAgentRuntimeVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAgentRuntimeVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - agentRuntimeId: The unique identifier of the AgentCore Runtime to list versions for.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAgentRuntimeVersionsPaginator(
        agentRuntimeId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAgentRuntimeVersionsRequest, ListAgentRuntimeVersionsResponse> {
        let input = ListAgentRuntimeVersionsRequest(
            agentRuntimeId: agentRuntimeId, 
            maxResults: maxResults
        )
        return self.listAgentRuntimeVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAgentRuntimes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAgentRuntimesPaginator(
        _ input: ListAgentRuntimesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAgentRuntimesRequest, ListAgentRuntimesResponse> {
        return .init(
            input: input,
            command: self.listAgentRuntimes,
            inputKey: \ListAgentRuntimesRequest.nextToken,
            outputKey: \ListAgentRuntimesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAgentRuntimes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAgentRuntimesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAgentRuntimesRequest, ListAgentRuntimesResponse> {
        let input = ListAgentRuntimesRequest(
            maxResults: maxResults
        )
        return self.listAgentRuntimesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listApiKeyCredentialProviders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listApiKeyCredentialProvidersPaginator(
        _ input: ListApiKeyCredentialProvidersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListApiKeyCredentialProvidersRequest, ListApiKeyCredentialProvidersResponse> {
        return .init(
            input: input,
            command: self.listApiKeyCredentialProviders,
            inputKey: \ListApiKeyCredentialProvidersRequest.nextToken,
            outputKey: \ListApiKeyCredentialProvidersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listApiKeyCredentialProviders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listApiKeyCredentialProvidersPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListApiKeyCredentialProvidersRequest, ListApiKeyCredentialProvidersResponse> {
        let input = ListApiKeyCredentialProvidersRequest(
            maxResults: maxResults
        )
        return self.listApiKeyCredentialProvidersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listBrowsers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listBrowsersPaginator(
        _ input: ListBrowsersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListBrowsersRequest, ListBrowsersResponse> {
        return .init(
            input: input,
            command: self.listBrowsers,
            inputKey: \ListBrowsersRequest.nextToken,
            outputKey: \ListBrowsersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listBrowsers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. The default value is 10. The maximum value is 50.
    ///   - type: The type of browsers to list. If not specified, all browser types are returned.
    ///   - logger: Logger used for logging
    @inlinable
    public func listBrowsersPaginator(
        maxResults: Int? = nil,
        type: ResourceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListBrowsersRequest, ListBrowsersResponse> {
        let input = ListBrowsersRequest(
            maxResults: maxResults, 
            type: type
        )
        return self.listBrowsersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCodeInterpreters(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCodeInterpretersPaginator(
        _ input: ListCodeInterpretersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCodeInterpretersRequest, ListCodeInterpretersResponse> {
        return .init(
            input: input,
            command: self.listCodeInterpreters,
            inputKey: \ListCodeInterpretersRequest.nextToken,
            outputKey: \ListCodeInterpretersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCodeInterpreters(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - type: The type of code interpreters to list.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCodeInterpretersPaginator(
        maxResults: Int? = nil,
        type: ResourceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCodeInterpretersRequest, ListCodeInterpretersResponse> {
        let input = ListCodeInterpretersRequest(
            maxResults: maxResults, 
            type: type
        )
        return self.listCodeInterpretersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listGatewayTargets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listGatewayTargetsPaginator(
        _ input: ListGatewayTargetsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListGatewayTargetsRequest, ListGatewayTargetsResponse> {
        return .init(
            input: input,
            command: self.listGatewayTargets,
            inputKey: \ListGatewayTargetsRequest.nextToken,
            outputKey: \ListGatewayTargetsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listGatewayTargets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - gatewayIdentifier: The identifier of the gateway to list targets for.
    ///   - maxResults: The maximum number of results to return in the response. If the total number of results is greater than this value, use the token returned in the response in the nextToken field when making another request to return the next batch of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listGatewayTargetsPaginator(
        gatewayIdentifier: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListGatewayTargetsRequest, ListGatewayTargetsResponse> {
        let input = ListGatewayTargetsRequest(
            gatewayIdentifier: gatewayIdentifier, 
            maxResults: maxResults
        )
        return self.listGatewayTargetsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listGateways(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listGatewaysPaginator(
        _ input: ListGatewaysRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListGatewaysRequest, ListGatewaysResponse> {
        return .init(
            input: input,
            command: self.listGateways,
            inputKey: \ListGatewaysRequest.nextToken,
            outputKey: \ListGatewaysResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listGateways(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in the response. If the total number of results is greater than this value, use the token returned in the response in the nextToken field when making another request to return the next batch of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listGatewaysPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListGatewaysRequest, ListGatewaysResponse> {
        let input = ListGatewaysRequest(
            maxResults: maxResults
        )
        return self.listGatewaysPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMemories(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMemoriesPaginator(
        _ input: ListMemoriesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMemoriesInput, ListMemoriesOutput> {
        return .init(
            input: input,
            command: self.listMemories,
            inputKey: \ListMemoriesInput.nextToken,
            outputKey: \ListMemoriesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMemories(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. The default value is 10. The maximum value is 50.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMemoriesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMemoriesInput, ListMemoriesOutput> {
        let input = ListMemoriesInput(
            maxResults: maxResults
        )
        return self.listMemoriesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOauth2CredentialProviders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOauth2CredentialProvidersPaginator(
        _ input: ListOauth2CredentialProvidersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOauth2CredentialProvidersRequest, ListOauth2CredentialProvidersResponse> {
        return .init(
            input: input,
            command: self.listOauth2CredentialProviders,
            inputKey: \ListOauth2CredentialProvidersRequest.nextToken,
            outputKey: \ListOauth2CredentialProvidersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOauth2CredentialProviders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOauth2CredentialProvidersPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOauth2CredentialProvidersRequest, ListOauth2CredentialProvidersResponse> {
        let input = ListOauth2CredentialProvidersRequest(
            maxResults: maxResults
        )
        return self.listOauth2CredentialProvidersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWorkloadIdentities(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkloadIdentitiesPaginator(
        _ input: ListWorkloadIdentitiesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWorkloadIdentitiesRequest, ListWorkloadIdentitiesResponse> {
        return .init(
            input: input,
            command: self.listWorkloadIdentities,
            inputKey: \ListWorkloadIdentitiesRequest.nextToken,
            outputKey: \ListWorkloadIdentitiesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWorkloadIdentities(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkloadIdentitiesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWorkloadIdentitiesRequest, ListWorkloadIdentitiesResponse> {
        let input = ListWorkloadIdentitiesRequest(
            maxResults: maxResults
        )
        return self.listWorkloadIdentitiesPaginator(input, logger: logger)
    }
}

extension BedrockAgentCoreControl.ListAgentRuntimeEndpointsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListAgentRuntimeEndpointsRequest {
        return .init(
            agentRuntimeId: self.agentRuntimeId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension BedrockAgentCoreControl.ListAgentRuntimeVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListAgentRuntimeVersionsRequest {
        return .init(
            agentRuntimeId: self.agentRuntimeId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension BedrockAgentCoreControl.ListAgentRuntimesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListAgentRuntimesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension BedrockAgentCoreControl.ListApiKeyCredentialProvidersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListApiKeyCredentialProvidersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension BedrockAgentCoreControl.ListBrowsersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListBrowsersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            type: self.type
        )
    }
}

extension BedrockAgentCoreControl.ListCodeInterpretersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListCodeInterpretersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            type: self.type
        )
    }
}

extension BedrockAgentCoreControl.ListGatewayTargetsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListGatewayTargetsRequest {
        return .init(
            gatewayIdentifier: self.gatewayIdentifier,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension BedrockAgentCoreControl.ListGatewaysRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListGatewaysRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension BedrockAgentCoreControl.ListMemoriesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListMemoriesInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension BedrockAgentCoreControl.ListOauth2CredentialProvidersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListOauth2CredentialProvidersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension BedrockAgentCoreControl.ListWorkloadIdentitiesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> BedrockAgentCoreControl.ListWorkloadIdentitiesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

// MARK: Waiters

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension BedrockAgentCoreControl {
    /// Waiter for operation ``getMemory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilMemoryCreated(
        _ input: GetMemoryInput,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetMemoryInput, _>(
            acceptors: [
                .init(state: .retry, matcher: try! JMESPathMatcher("memory.status", expected: "CREATING")),
                .init(state: .success, matcher: try! JMESPathMatcher("memory.status", expected: "ACTIVE")),
                .init(state: .failure, matcher: try! JMESPathMatcher("memory.status", expected: "FAILED")),
            ],
            command: self.getMemory
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getMemory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - memoryId: The unique identifier of the memory to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilMemoryCreated(
        memoryId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetMemoryInput(
            memoryId: memoryId
        )
        try await self.waitUntilMemoryCreated(input, logger: logger)
    }
}
